{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyNb8h/w3h8i4Tt71h5T0i6W",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/DanielWarfield1/MLWritingAndResearch/blob/main/sslDemo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Self Supervised Learning with Projection Heads and Contrastive Learning\n",
        "In this demo, I train a simple convolutional neural network on a very sparse\n",
        "version of MNIST. 60,000 training examples, I only preserve 200 labels (meaning\n",
        "we have 59,800 unlabled training examples, and 200 labled training examples).\n",
        "In this notebook:\n",
        "\n",
        " - A simple supervised model is trained on only the 200 labels, resulting in a\n",
        " test set accuracy of 52.5%\n",
        " - A model is trained via self-supervised contrastive learning, yielding a test set accuracy of 59.7%\n",
        " - A model is trained via self-supervised contrastive learning, with a discarded projection head before refinement, yielding a test set accuracy of 63.6%\n",
        "\n",
        "(results may be different due to stocasticity)\n",
        "\n",
        "Given the incredible sparsity of the labled training set, I think 63.6% accuracy\n",
        "is quite impressive, especially considering this is a proof of concept notebook\n",
        "without significant hyperparameter refinement. This shows the power of self supervised learning using contrastive learning, and the importance of the projection head in that process.\n",
        "\n",
        "If you like what you see, and want to work with me, visit https://danielwarfield.dev\n",
        "\n",
        "# Table Of Contents\n",
        "\n",
        " - **Dataset Preperation:** Convert MNIST data into a very sparsely labled dataset\n",
        " - **Defining Model:** Create a simple convolutional netowrk with a fully connected projection head\n",
        " - **Training with Only Supervised Learning:** Establish baseline performance with only supervised learning\n",
        " - **Defining Augmentation:** Define the image augmentations necessary for self supervised learning\n",
        " - **Defining Contrastive Loss:** Define the loss function necessary for self supervised learning.\n",
        " - **Self Supervised Training:** Train the model to have general image understanding, without human defined lables, via self supervised learning with contrastive loss.\n",
        " - **Self Supervised Learning Training Progress:** A visual of the loss reduction compared to the learning rate scheduler, which is practically useful in understanding if SSL is actually doing anything productive\n",
        " - **Fine Tuning Self Supervised Model with Supervised Learning:** Training on the sparsely labled dataset, both with the original head from SSL, as well as new randomly initialized head\n",
        " - **Discussion:** A brief discussion\n"
      ],
      "metadata": {
        "id": "JwBCCtPSGkxz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dataset Preperation\n",
        " - Setup PyTorch\n",
        " - Downloading the MNIST dataset\n",
        " - Remove labels from all but 200 training examples\n",
        " - Reformat the data into PyTorch tensors"
      ],
      "metadata": {
        "id": "UncrQc1pIvaD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Downloading and rendering sample MNIST data\n",
        "\"\"\"\n",
        "\n",
        "#torch setup\n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.datasets as datasets\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "\n",
        "#downloading mnist\n",
        "mnist_trainset = datasets.MNIST(root='./data', train=True,\n",
        "                                download=True, transform=None)\n",
        "mnist_testset = datasets.MNIST(root='./data', train=False,\n",
        "                               download=True, transform=None)\n",
        "\n",
        "#printing lengths\n",
        "print('length of the training set: {}'.format(len(mnist_trainset)))\n",
        "print('length of the test set: {}'.format(len(mnist_testset)))\n",
        "\n",
        "#rendering a few examples\n",
        "for i in range(3):\n",
        "  print('the number {}:'.format(mnist_trainset[i][1]))\n",
        "  mnist_trainset[i][0].show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 551
        },
        "id": "qbp5sfo9Gszq",
        "outputId": "1296c4f3-bf4d-4d0d-c939-aadbd138a945"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 9912422/9912422 [00:00<00:00, 215649485.43it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 28881/28881 [00:00<00:00, 89201541.84it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1648877/1648877 [00:00<00:00, 69067054.78it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4542/4542 [00:00<00:00, 21003890.59it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "length of the training set: 60000\n",
            "length of the test set: 10000\n",
            "the number 5:\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=L size=28x28 at 0x7F8F2441FC10>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABAElEQVR4nGNgGMyAWUhIqK5jvdSy/9/rGRgYGFhgEnJsVjYCwQwMDAxPJgV+vniQgYGBgREqZ7iXH8r6l/SV4dn7m8gmCt3++/fv37/Htn3/iMW+gDnZf/+e5WbQnoXNNXyMs/5GoQoxwVmf/n9kSGFiwAW49/11wynJoPzx4YIcRlyygR/+/i2XxCWru+vv32nSuGQFYv/83Y3b4p9/fzpAmSyoMnohpiwM1w5h06Q+5enfv39/bcMiJVF09+/fv39P+mFKiTtd/fv3799jgZiBJLT69t+/f/8eDuDEkDJf8+jv379/v7Ryo4qzMDAwMAQGMjBc3/y35wM2V1IfAABFF16Aa0wAOwAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "the number 0:\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=L size=28x28 at 0x7F8F21771BD0>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA/0lEQVR4nGNgGHhgPP/vfCMccgbv/vz58xa7nNnjv3/ev/xjyYYpxWXz4M/fP6dC/vytgggwIUnOPCDDwMBgxHOQQRdD0tibkfFQKeOL85OYGLG5ZTOPd6UoA8Pfz2gOVlv69+WFEAj775+lKHLsm/58cBeWgUkeRpG0/PPHHs5Blzz2dx+C8//vEWTX+hj834SQ/Pf/ArLG0D/PJOHWt//dxYMqeR8u1/znoTsDquREKMtg6Z+1DKgg7O9DCKPo3d9FaHIMoX9+TjKQDd308O/95RaYkn/+PL3+58+fI03oUgwMMsf//Pn758/LiZhSDAwMkg1//v7pVcUqR1cAAKxwbkTVIzd2AAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "the number 4:\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=L size=28x28 at 0x7F8F2441FC10>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA1ElEQVR4nGNgGArA+YU6AwMDAwMTAwMDg10gqqTpGQaEpEMQihyTohwjgndnMYqk9L9FSDqZUE2dw3AbIaknjirJz7AbIenFiSInrsjwFCGpznAVWbJH/NZnCIuFgYGBgeE0XIbPI8aNofkDsqQQAwODPpOzDFs00/eTP1nOQlUyMjAwTEv/8IiBQY/xz7drJ88cfPlEkI0BoTProRUDA8OjjddOMDAwMKSJ3mPACVb+64QxmbBIb8AnyYBHklEVj+R/JjySDJb4jMVj5/b/OB1IJQAAg3ksR3QPgSAAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Creating un-labled data and transforming the data into more familiar types\n",
        "\"\"\"\n",
        "\n",
        "from tqdm import tqdm\n",
        "import numpy as np\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "\n",
        "# ========== Data Extraction ==========\n",
        "# unlabeling some data, and one hot encoding the labels which remain\n",
        "# =====================================\n",
        "\n",
        "partition_index = 200\n",
        "\n",
        "def one_hot(y):\n",
        "  #For converting a numpy array of 0-9 into a one hot encoding of vectors of length 10\n",
        "  b = np.zeros((y.size, y.max() + 1))\n",
        "  b[np.arange(y.size), y] = 1\n",
        "  return b\n",
        "\n",
        "print('processing labeld training x and y')\n",
        "train_x = np.asarray([np.asarray(mnist_trainset[i][0]) for i in tqdm(range(partition_index))])\n",
        "train_y = one_hot(np.asarray([np.asarray(mnist_trainset[i][1]) for i in tqdm(range(partition_index))]))\n",
        "\n",
        "print('processing unlabled training data')\n",
        "train_unlabled = np.asarray([np.asarray(mnist_trainset[i][0]) for i in tqdm(range(partition_index,len(mnist_trainset)))])\n",
        "\n",
        "print('processing labeld test x and y')\n",
        "test_x = np.asarray([np.asarray(mnist_testset[i][0]) for i in tqdm(range(len(mnist_testset)))])\n",
        "test_y = one_hot(np.asarray([np.asarray(mnist_testset[i][1]) for i in tqdm(range(len(mnist_testset)))]))\n",
        "\n",
        "# ========== Data Reformatting ==========\n",
        "# adding a channel dimension and converting to pytorch\n",
        "# =====================================\n",
        "\n",
        "#adding a dimension to all X values to put them in the proper shape\n",
        "#(batch size, channels, x, y)\n",
        "print('reformatting shape...')\n",
        "train_x = np.expand_dims(train_x, 1)\n",
        "train_unlabled = np.expand_dims(train_unlabled, 1)\n",
        "test_x = np.expand_dims(test_x, 1)\n",
        "\n",
        "#converting data to pytorch type\n",
        "torch_train_x = torch.tensor(train_x.astype(np.float32), requires_grad=True).to(device)\n",
        "torch_train_y = torch.tensor(train_y).to(device)\n",
        "torch_test_x = torch.tensor(test_x.astype(np.float32), requires_grad=True).to(device)\n",
        "torch_test_y = torch.tensor(test_y).to(device)\n",
        "torch_train_unlabled = torch.tensor(train_unlabled.astype(np.float32), requires_grad=True).to(device)\n",
        "\n",
        "print('done')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "57-rgCpZK20X",
        "outputId": "cf8a0d24-6c10-478d-b5ea-4519ce4880f7"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "processing labeld training x and y\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 200/200 [00:00<00:00, 9037.79it/s]\n",
            "100%|██████████| 200/200 [00:00<00:00, 13853.33it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "processing unlabled training data\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 59800/59800 [00:04<00:00, 12532.35it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "processing labeld test x and y\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 10000/10000 [00:00<00:00, 18298.73it/s]\n",
            "100%|██████████| 10000/10000 [00:00<00:00, 42868.00it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "reformatting shape...\n",
            "done\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Defining Model\n",
        "The model is a very simple, low parameter convolutional model. There is a\n",
        "convolutional backbone with max pooling, and a fully connected head. The \"head\"\n",
        "is what is refered to as the \"projection head\" in the original blog post, and\n",
        "is re-initialized later in one of the examples."
      ],
      "metadata": {
        "id": "5e02je9BJPse"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Using PyTorch to create a modified, smaller version of AlexNet\n",
        "\"\"\"\n",
        "import torch.nn.functional as F\n",
        "import torch.nn as nn\n",
        "\n",
        "class Backbone(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Backbone, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(1, 16, 3)\n",
        "        self.conv2 = nn.Conv2d(16, 16, 3)\n",
        "        self.conv3 = nn.Conv2d(16, 32, 3)\n",
        "\n",
        "        if torch.cuda.is_available():\n",
        "            self.cuda()\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.max_pool2d(F.relu(self.conv1(x)), 2)\n",
        "        x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
        "        x = F.max_pool2d(F.relu(self.conv3(x)), 2)\n",
        "        x = torch.flatten(x, 1)\n",
        "        return x\n",
        "\n",
        "\n",
        "class Head(nn.Module):\n",
        "    def __init__(self, n_class=10):\n",
        "        super(Head, self).__init__()\n",
        "        self.fc1 = nn.Linear(32, 32)\n",
        "        self.fc2 = nn.Linear(32, 16)\n",
        "        self.fc3 = nn.Linear(16, n_class)\n",
        "\n",
        "        if torch.cuda.is_available():\n",
        "            self.cuda()\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return F.softmax(x,1)\n",
        "\n",
        "\n",
        "class Model(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Model, self).__init__()\n",
        "        self.backbone = Backbone()\n",
        "        self.head = Head()\n",
        "\n",
        "        if torch.cuda.is_available():\n",
        "            self.cuda()\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.backbone(x)\n",
        "        x = self.head(x)\n",
        "        return x\n",
        "\n",
        "model_baseline = Model()\n",
        "print(model_baseline(torch_train_x[:1]).shape)\n",
        "model_baseline"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I0fEzqKaOHID",
        "outputId": "faf9dc79-cedb-4984-b93b-1b39c8649fb8"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 10])\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Model(\n",
              "  (backbone): Backbone(\n",
              "    (conv1): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1))\n",
              "    (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1))\n",
              "    (conv3): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n",
              "  )\n",
              "  (head): Head(\n",
              "    (fc1): Linear(in_features=32, out_features=32, bias=True)\n",
              "    (fc2): Linear(in_features=32, out_features=16, bias=True)\n",
              "    (fc3): Linear(in_features=16, out_features=10, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training with Only Supervised Learning\n",
        "attempting to train a model using only supervised learning with the 200 labled\n",
        "training samples. Naturally, performance is very poor as a result of a lack of\n",
        "sufficient data."
      ],
      "metadata": {
        "id": "MxYvusmEJrue"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Training model using only supervised learning, and rendering the results\n",
        "\"\"\"\n",
        "\n",
        "def supervised_train(model):\n",
        "\n",
        "    #defining key hyperparamaters explicitly (instead of hyperparamater search)\n",
        "    batch_size = 64\n",
        "    lr = 0.001\n",
        "    momentum = 0.9\n",
        "    num_epochs = 20000\n",
        "\n",
        "    #defining a stocastic gradient descent optimizer\n",
        "    optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=momentum)\n",
        "\n",
        "    #defining loss function\n",
        "    loss_fn = torch.nn.CrossEntropyLoss()\n",
        "\n",
        "    train_hist = []\n",
        "    test_hist = []\n",
        "    test_accuracy = []\n",
        "\n",
        "    for epoch in tqdm(range(num_epochs)):\n",
        "\n",
        "        #iterating over all batches\n",
        "        for i in range(int(len(train_x)/batch_size)-1):\n",
        "\n",
        "            #Put the model in training mode, so that things like dropout work\n",
        "            model.train(True)\n",
        "\n",
        "            # Zero gradients\n",
        "            optimizer.zero_grad()\n",
        "\n",
        "            #extracting X and y values from the batch\n",
        "            X = torch_train_x[i*batch_size: (i+1)*batch_size]\n",
        "            y = torch_train_y[i*batch_size: (i+1)*batch_size]\n",
        "\n",
        "            # Make predictions for this batch\n",
        "            y_pred = model(X)\n",
        "\n",
        "            #compute gradients\n",
        "            loss_fn(model(X), y).backward()\n",
        "\n",
        "            # Adjust learning weights\n",
        "            optimizer.step()\n",
        "\n",
        "        with torch.no_grad():\n",
        "\n",
        "            #Disable things like dropout\n",
        "            model.train(False)\n",
        "\n",
        "            #calculating epoch training and test loss\n",
        "            train_loss = loss_fn(model(torch_train_x), torch_train_y).cpu().numpy()\n",
        "            y_pred_test = model(torch_test_x)\n",
        "            test_loss = loss_fn(y_pred_test, torch_test_y).cpu().numpy()\n",
        "\n",
        "            train_hist.append(train_loss)\n",
        "            test_hist.append(test_loss)\n",
        "\n",
        "            #computing test accuracy\n",
        "            matches = np.equal(np.argmax(y_pred_test.cpu().numpy(), axis=1), np.argmax(torch_test_y.cpu().numpy(), axis=1))\n",
        "            test_accuracy.append(matches.sum()/len(matches))\n",
        "\n",
        "    import matplotlib.pyplot as plt\n",
        "    plt.plot(train_hist, label = 'train loss')\n",
        "    plt.plot(test_hist, label = 'test loss')\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "    plt.plot(test_accuracy, label = 'test accuracy')\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "\n",
        "    maxacc = max(test_accuracy)\n",
        "    print('max accuracy: {}'.format(maxacc))\n",
        "\n",
        "    return maxacc\n",
        "\n",
        "supervised_maxacc = supervised_train(model_baseline)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 880
        },
        "id": "XpDWuQ-XZm92",
        "outputId": "e96a3506-0c9a-45c1-9820-94dadc6ece11"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 20000/20000 [14:13<00:00, 23.45it/s]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "max accuracy: 0.5249\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Defining Augmentation\n",
        "Augmentations are a crucial part of contrastive self supervision. This function takes a tensor and produces augmentations which morph the images of numbers such they are signifficantly changed, but still recognizable as the original number.\n",
        "\n",
        "A reference I used:\n",
        "https://theaisummer.com/simclr/\n"
      ],
      "metadata": {
        "id": "SI27qCBQ9HZf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision.transforms as T\n",
        "\n",
        "class Augment:\n",
        "   \"\"\"\n",
        "   A stochastic data augmentation module\n",
        "   Transforms any given data example randomly\n",
        "   resulting in two correlated views of the same example,\n",
        "   denoted x ̃i and x ̃j, which we consider as a positive pair.\n",
        "   \"\"\"\n",
        "\n",
        "   def __init__(self):\n",
        "\n",
        "       blur = T.GaussianBlur((3, 3), (0.1, 2.0))\n",
        "\n",
        "       self.train_transform = torch.nn.Sequential(\n",
        "           T.RandomAffine(degrees = (-50,50), translate = (0.1,0.1), scale=(0.5,1.5), shear=0.2),\n",
        "           T.RandomPerspective(0.4,0.5),\n",
        "           T.RandomPerspective(0.2,0.5),\n",
        "           T.RandomPerspective(0.2,0.5),\n",
        "           T.RandomApply([blur], p=0.25),\n",
        "           T.RandomApply([blur], p=0.25)\n",
        "       )\n",
        "\n",
        "   def __call__(self, x):\n",
        "       return self.train_transform(x), self.train_transform(x)\n",
        "\n",
        "a = Augment()\n",
        "\n",
        "i = 2\n",
        "plt.imshow(torch_train_unlabled.cpu().detach().numpy()[i,0])\n",
        "plt.show()\n",
        "\n",
        "aug = a(torch_train_unlabled[0:100])\n",
        "\n",
        "plt.imshow(aug[0].cpu().detach().numpy()[i,0])\n",
        "plt.show()\n",
        "plt.imshow(aug[0].cpu().detach().numpy()[i+1,0])\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "16YFOFSPWK01",
        "outputId": "367988d6-988e-4cb8-9376-181b03124f7e"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Defining Contrastive Loss\n",
        "Contrastiv loss is the loss function which defines how the model should seperate different examples. In essence, Contrastive loss punishes when similar examples are far apart, and when differnt examples are close together.\n",
        "\n",
        "<iframe src=\"https://giphy.com/embed/8SZhj0qY3XlHcr1150\" width=\"432\" height=\"480\" frameBorder=\"0\" class=\"giphy-embed\" allowFullScreen></iframe><p><a href=\"https://giphy.com/gifs/simclr-8SZhj0qY3XlHcr1150\">A Visual Demonstration of Contrastive Loss</a></p>\n",
        "\n",
        "A reference I used:\n",
        "https://theaisummer.com/simclr/"
      ],
      "metadata": {
        "id": "n22VuhGjKh-3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class ContrastiveLoss(nn.Module):\n",
        "   \"\"\"\n",
        "   Vanilla Contrastive loss, also called InfoNceLoss as in SimCLR paper\n",
        "   \"\"\"\n",
        "   def __init__(self, batch_size, temperature=0.5):\n",
        "       \"\"\"\n",
        "       Defining certain constants used between calculations. The mask is important\n",
        "       in understanding which are positive and negative examples. For more\n",
        "       information see https://theaisummer.com/simclr/\n",
        "       \"\"\"\n",
        "       super().__init__()\n",
        "       self.batch_size = batch_size\n",
        "       self.temperature = temperature\n",
        "       self.mask = (~torch.eye(batch_size * 2, batch_size * 2, dtype=bool)).float().to(device)\n",
        "\n",
        "   def calc_similarity_batch(self, a, b):\n",
        "       \"\"\"\n",
        "       Defines the cosin similarity between one example, and all other examples.\n",
        "       For more information see https://theaisummer.com/simclr/\n",
        "       \"\"\"\n",
        "       representations = torch.cat([a, b], dim=0)\n",
        "       return F.cosine_similarity(representations.unsqueeze(1), representations.unsqueeze(0), dim=2)\n",
        "\n",
        "   def forward(self, proj_1, proj_2):\n",
        "       \"\"\"\n",
        "       The actual loss function, where proj_1 and proj_2 are embeddings from the\n",
        "       projection head. This function calculates the cosin similarity between\n",
        "       all vectors, and rewards closeness between examples which come from the\n",
        "       same example, and farness for examples which do not. For more information\n",
        "       see https://theaisummer.com/simclr/\n",
        "       \"\"\"\n",
        "       batch_size = proj_1.shape[0]\n",
        "       z_i = F.normalize(proj_1, p=2, dim=1)\n",
        "       z_j = F.normalize(proj_2, p=2, dim=1)\n",
        "\n",
        "       similarity_matrix = self.calc_similarity_batch(z_i, z_j)\n",
        "\n",
        "       sim_ij = torch.diag(similarity_matrix, batch_size)\n",
        "       sim_ji = torch.diag(similarity_matrix, -batch_size)\n",
        "\n",
        "       positives = torch.cat([sim_ij, sim_ji], dim=0)\n",
        "\n",
        "       nominator = torch.exp(positives / self.temperature)\n",
        "\n",
        "       denominator = self.mask * torch.exp(similarity_matrix / self.temperature)\n",
        "\n",
        "       all_losses = -torch.log(nominator / torch.sum(denominator, dim=1))\n",
        "       loss = torch.sum(all_losses) / (2 * self.batch_size)\n",
        "       return loss"
      ],
      "metadata": {
        "id": "wvTMpmzZ9HAQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        },
        "outputId": "65abcb2a-dbbc-414f-f856-4a32b68dc6f8"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-4c45096fbe55>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mclass\u001b[0m \u001b[0mContrastiveLoss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mModule\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m    \"\"\"\n\u001b[1;32m      3\u001b[0m    \u001b[0mVanilla\u001b[0m \u001b[0mContrastive\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malso\u001b[0m \u001b[0mcalled\u001b[0m \u001b[0mInfoNceLoss\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mSimCLR\u001b[0m \u001b[0mpaper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m    \"\"\"\n\u001b[1;32m      5\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtemperature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'nn' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "testing the loss function on fake data, to see if it works effectively\n",
        "\"\"\"\n",
        "loss = ContrastiveLoss(torch_train_x.shape[0]).forward\n",
        "fake_proj_0, fake_proj_1 = a(torch_train_x)\n",
        "fake_proj_0 = fake_proj_0[:,0,:,0]\n",
        "fake_proj_1 = fake_proj_1[:,0,:,0]\n",
        "loss(fake_proj_0, fake_proj_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k9CHfs2jRDPR",
        "outputId": "b7740cc6-c9fa-48e2-f894-62b2fb6a3c63"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(6.1486, device='cuda:0', grad_fn=<DivBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Self Supervised Training\n",
        "\n",
        "Pairing augmentations, and the contrastive loss function, to train a model to be able to distinguish between similar and different images of charecters. This model will then serve as an initialization for further model fine tuning via supervised learning.\n",
        "\n",
        "\n",
        "**Useful References:**\n",
        "\n",
        "General: https://theaisummer.com/simclr/\n",
        "\n",
        "PyTorch Schedulers: https://towardsdatascience.com/a-visual-guide-to-learning-rate-schedulers-in-pytorch-24bbb262c863#eec7"
      ],
      "metadata": {
        "id": "qV69j8yDhe2x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.optim.lr_scheduler import ExponentialLR\n",
        "\n",
        "model = Model()\n",
        "model.train()\n",
        "\n",
        "batch_size = 512\n",
        "epoch_size = round(torch_train_unlabled.shape[0]/batch_size)-1\n",
        "num_epochs = 100\n",
        "patience = 5\n",
        "cutoff_ratio = 0.001\n",
        "\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
        "num_examples = train_unlabled.shape[0]\n",
        "lossfn = ContrastiveLoss(batch_size).forward\n",
        "augmentfn = Augment() #augment function\n",
        "\n",
        "loss_hist = []\n",
        "improvement_hist = []\n",
        "schedule_hist = []\n",
        "\n",
        "scheduler = ExponentialLR(optimizer,\n",
        "                          gamma = 0.95)\n",
        "\n",
        "patience_count=0\n",
        "avg_loss = 1e10\n",
        "for i in range(num_epochs):\n",
        "\n",
        "    print('epoch {}/{}'.format(i,num_epochs))\n",
        "\n",
        "    total_loss = 0\n",
        "    loss_change = 0\n",
        "\n",
        "    for j in tqdm(range(epoch_size)):\n",
        "\n",
        "        #getting random batch\n",
        "        X = torch_train_unlabled[j*batch_size: (j+1)*batch_size]\n",
        "\n",
        "        #creating pairs of augmented batches\n",
        "        X_aug_i, X_aug_j = augmentfn(X)\n",
        "\n",
        "        #ensuring gradients are zero\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        #passing through the model\n",
        "        z_i = model(X_aug_i)\n",
        "        z_j = model(X_aug_j)\n",
        "\n",
        "        #calculating loss on the model embeddings, and computing gradients\n",
        "        loss = lossfn(z_i, z_j)\n",
        "        loss.backward()\n",
        "\n",
        "        # Adjust learning weights\n",
        "        optimizer.step()\n",
        "\n",
        "        #checking to see if backpropegation resulted in a reduction of the loss function\n",
        "        if True:\n",
        "            #passing through the model, now that parameters have been updated\n",
        "            z_i = model(X_aug_i)\n",
        "            z_j = model(X_aug_j)\n",
        "\n",
        "            #calculating new loss value\n",
        "            new_loss = lossfn(z_i, z_j)\n",
        "\n",
        "            loss_change += new_loss.cpu().detach().numpy() - loss.cpu().detach().numpy()\n",
        "\n",
        "        total_loss += loss.cpu().detach().numpy()\n",
        "\n",
        "        #step learning rate scheduler\n",
        "        schedule_hist.append(scheduler.get_last_lr())\n",
        "\n",
        "    scheduler.step()\n",
        "\n",
        "    #calculating percentage loss reduction\n",
        "    new_avg_loss = total_loss/epoch_size\n",
        "    per_loss_reduction = (avg_loss-new_avg_loss)/avg_loss\n",
        "    print('Percentage Loss Reduction: {}'.format(per_loss_reduction))\n",
        "\n",
        "    #deciding to stop if loss is not decreasing fast enough\n",
        "    if per_loss_reduction < cutoff_ratio:\n",
        "        patience_count+=1\n",
        "        print('patience counter: {}'.format(patience_count))\n",
        "        if patience_count > patience:\n",
        "            break\n",
        "    else:\n",
        "        patience_count = 0\n",
        "\n",
        "    #setting new loss as previous loss\n",
        "    avg_loss = new_avg_loss\n",
        "\n",
        "    #book keeping\n",
        "    avg_improvement = loss_change/epoch_size\n",
        "    loss_hist.append(avg_loss)\n",
        "    improvement_hist.append(avg_improvement)\n",
        "    print('Average Loss: {}'.format(avg_loss))\n",
        "    print('Average Loss change (if calculated): {}'.format(avg_improvement))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0GhOjL4Lh-qx",
        "outputId": "3e161386-1306-47dd-ac0b-7d7a4e720d26"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch 0/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:27<00:00,  4.27it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.9999999993151959\n",
            "Average Loss: 6.848041291894583\n",
            "Average Loss change (if calculated): -0.01992147133268159\n",
            "epoch 1/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.54it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.02761450766361156\n",
            "Average Loss: 6.658936003158832\n",
            "Average Loss change (if calculated): -0.025475666440766435\n",
            "epoch 2/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.54it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.02182705715330352\n",
            "Average Loss: 6.513591026437694\n",
            "Average Loss change (if calculated): -0.020024377724220013\n",
            "epoch 3/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.38it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.00788365712569554\n",
            "Average Loss: 6.462240108128252\n",
            "Average Loss change (if calculated): -0.019849218171218347\n",
            "epoch 4/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.008046210388291142\n",
            "Average Loss: 6.4102435646385985\n",
            "Average Loss change (if calculated): -0.01674765965034222\n",
            "epoch 5/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0037767664200002295\n",
            "Average Loss: 6.386033571999649\n",
            "Average Loss change (if calculated): -0.015815582768670445\n",
            "epoch 6/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.45it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0005590571778010578\n",
            "patience counter: 1\n",
            "Average Loss: 6.382463414093544\n",
            "Average Loss change (if calculated): -0.016948510860574657\n",
            "epoch 7/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.41it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.006255775227826797\n",
            "Average Loss: 6.342536157575147\n",
            "Average Loss change (if calculated): -0.012253827062146417\n",
            "epoch 8/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.47it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0036662154073206325\n",
            "Average Loss: 6.3192830537927565\n",
            "Average Loss change (if calculated): -0.011606475402568948\n",
            "epoch 9/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.45it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0037872264024975274\n",
            "Average Loss: 6.295350498166577\n",
            "Average Loss change (if calculated): -0.011138093882593614\n",
            "epoch 10/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0023387918897786767\n",
            "patience counter: 1\n",
            "Average Loss: 6.3100740128550035\n",
            "Average Loss change (if calculated): -0.012399833777855182\n",
            "epoch 11/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.005331512517209969\n",
            "Average Loss: 6.276431774270946\n",
            "Average Loss change (if calculated): -0.010326529371327367\n",
            "epoch 12/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.47it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.002182862570463071\n",
            "patience counter: 1\n",
            "Average Loss: 6.290132362267067\n",
            "Average Loss change (if calculated): -0.01054087178460483\n",
            "epoch 13/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.45it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0025214766543459302\n",
            "Average Loss: 6.274271940362865\n",
            "Average Loss change (if calculated): -0.01020263803416285\n",
            "epoch 14/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.45it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.001710597440703886\n",
            "Average Loss: 6.2635391868394\n",
            "Average Loss change (if calculated): -0.010184752530065077\n",
            "epoch 15/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.46it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.004075421231451637\n",
            "Average Loss: 6.238012626253325\n",
            "Average Loss change (if calculated): -0.008724278417126885\n",
            "epoch 16/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.47it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.002272293077185555\n",
            "patience counter: 1\n",
            "Average Loss: 6.252187219159357\n",
            "Average Loss change (if calculated): -0.008212295071832064\n",
            "epoch 17/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0013656145150851547\n",
            "Average Loss: 6.243649141541843\n",
            "Average Loss change (if calculated): -0.008183462866421404\n",
            "epoch 18/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.45it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.004252847162136745\n",
            "Average Loss: 6.217095856008859\n",
            "Average Loss change (if calculated): -0.007589093570051522\n",
            "epoch 19/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.49it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.001597395587245353\n",
            "Average Loss: 6.207164694522989\n",
            "Average Loss change (if calculated): -0.0067755682715054215\n",
            "epoch 20/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -3.326060399582363e-05\n",
            "patience counter: 1\n",
            "Average Loss: 6.20737114856983\n",
            "Average Loss change (if calculated): -0.005731401772334658\n",
            "epoch 21/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.52it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0024564460853848807\n",
            "Average Loss: 6.192123076011395\n",
            "Average Loss change (if calculated): -0.005882633143457873\n",
            "epoch 22/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.47it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.002820739190953576\n",
            "patience counter: 1\n",
            "Average Loss: 6.209589440247108\n",
            "Average Loss change (if calculated): -0.006083077397839776\n",
            "epoch 23/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.45it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0037994676009638338\n",
            "Average Loss: 6.185996306353602\n",
            "Average Loss change (if calculated): -0.006368147915807264\n",
            "epoch 24/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.00138558803457343\n",
            "patience counter: 1\n",
            "Average Loss: 6.194567548817601\n",
            "Average Loss change (if calculated): -0.0050496561773892105\n",
            "epoch 25/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.47it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.001739002427318402\n",
            "Average Loss: 6.18379518081402\n",
            "Average Loss change (if calculated): -0.0050808479045999465\n",
            "epoch 26/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.49it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0008140722737288555\n",
            "patience counter: 1\n",
            "Average Loss: 6.1888292370171385\n",
            "Average Loss change (if calculated): -0.005540888884971882\n",
            "epoch 27/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0012436642841019805\n",
            "patience counter: 2\n",
            "Average Loss: 6.196526062899623\n",
            "Average Loss change (if calculated): -0.0050919549218539535\n",
            "epoch 28/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.52it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.002822281998782418\n",
            "Average Loss: 6.179037718937315\n",
            "Average Loss change (if calculated): -0.003972867439533102\n",
            "epoch 29/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.001992552773553289\n",
            "patience counter: 1\n",
            "Average Loss: 6.191349777682074\n",
            "Average Loss change (if calculated): -0.005119693690332873\n",
            "epoch 30/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.47it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0022358185685367408\n",
            "Average Loss: 6.177507042884827\n",
            "Average Loss change (if calculated): -0.004085248914258233\n",
            "epoch 31/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0006532939101641356\n",
            "patience counter: 1\n",
            "Average Loss: 6.181542770615939\n",
            "Average Loss change (if calculated): -0.004740028545774263\n",
            "epoch 32/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.000784128474876562\n",
            "patience counter: 2\n",
            "Average Loss: 6.186389894321047\n",
            "Average Loss change (if calculated): -0.003937930896364409\n",
            "epoch 33/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.003949966024131481\n",
            "Average Loss: 6.161953864426448\n",
            "Average Loss change (if calculated): -0.003628406031378384\n",
            "epoch 34/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0016945526785947618\n",
            "patience counter: 1\n",
            "Average Loss: 6.172395619852789\n",
            "Average Loss change (if calculated): -0.003912605088332604\n",
            "epoch 35/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0004375533247947622\n",
            "patience counter: 2\n",
            "Average Loss: 6.175096372078205\n",
            "Average Loss change (if calculated): -0.003349102776626061\n",
            "epoch 36/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0012742610150902104\n",
            "Average Loss: 6.16722768750684\n",
            "Average Loss change (if calculated): -0.002994746997438628\n",
            "epoch 37/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.52it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0019300190126741103\n",
            "Average Loss: 6.155324820814462\n",
            "Average Loss change (if calculated): -0.0032668442561708646\n",
            "epoch 38/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.49it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -4.092951281547135e-05\n",
            "patience counter: 1\n",
            "Average Loss: 6.155576755260599\n",
            "Average Loss change (if calculated): -0.0025728529897229425\n",
            "epoch 39/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 6.54566264114429e-05\n",
            "patience counter: 2\n",
            "Average Loss: 6.155173831972583\n",
            "Average Loss change (if calculated): -0.0026212560719457165\n",
            "epoch 40/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.000517431642151756\n",
            "patience counter: 3\n",
            "Average Loss: 6.151988950268976\n",
            "Average Loss change (if calculated): -0.0026378138311978043\n",
            "epoch 41/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0026367418561416066\n",
            "patience counter: 4\n",
            "Average Loss: 6.168210157032671\n",
            "Average Loss change (if calculated): -0.0034151159483810953\n",
            "epoch 42/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0006359691412457083\n",
            "patience counter: 5\n",
            "Average Loss: 6.1642873657160795\n",
            "Average Loss change (if calculated): -0.0024158050274026804\n",
            "epoch 43/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0031194906405234515\n",
            "Average Loss: 6.145057928973231\n",
            "Average Loss change (if calculated): -0.002062086401314571\n",
            "epoch 44/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.49it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.00104348903531477\n",
            "patience counter: 1\n",
            "Average Loss: 6.151470229543489\n",
            "Average Loss change (if calculated): -0.002304512878944134\n",
            "epoch 45/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0017705101076947178\n",
            "Average Loss: 6.140578989324899\n",
            "Average Loss change (if calculated): -0.0016805879000959725\n",
            "epoch 46/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.48it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0015475938100078697\n",
            "patience counter: 1\n",
            "Average Loss: 6.150082111358643\n",
            "Average Loss change (if calculated): -0.002191847768323175\n",
            "epoch 47/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:26<00:00,  4.43it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.002687220899755318\n",
            "Average Loss: 6.133555482173788\n",
            "Average Loss change (if calculated): -0.0015508388650828395\n",
            "epoch 48/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.47it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0010425788375602624\n",
            "patience counter: 1\n",
            "Average Loss: 6.139950197318504\n",
            "Average Loss change (if calculated): -0.001782322752064672\n",
            "epoch 49/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0005400828503249148\n",
            "patience counter: 2\n",
            "Average Loss: 6.143266279121925\n",
            "Average Loss change (if calculated): -0.0015961342844469793\n",
            "epoch 50/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -7.155445804375024e-05\n",
            "patience counter: 3\n",
            "Average Loss: 6.143705857211146\n",
            "Average Loss change (if calculated): -0.0015071753797859981\n",
            "epoch 51/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0011742967582260447\n",
            "patience counter: 4\n",
            "Average Loss: 6.150920391082764\n",
            "Average Loss change (if calculated): -0.0015028591813712284\n",
            "epoch 52/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.49it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: 0.0008801267878934605\n",
            "patience counter: 5\n",
            "Average Loss: 6.145506801276372\n",
            "Average Loss change (if calculated): -0.0014941610138991784\n",
            "epoch 53/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 116/116 [00:25<00:00,  4.49it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage Loss Reduction: -0.0012384643495572142\n",
            "patience counter: 6\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Self Supervised Learning Training Progress\n",
        "prints a graph of the learning rate and loss results from self supervised learning"
      ],
      "metadata": {
        "id": "GLTkWRxkO9xH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(schedule_hist, label='learning rate')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "plt.plot(loss_hist, label = 'loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "2pcyFRkjpbbW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 843
        },
        "outputId": "d6b1aede-e3d3-4ee4-f4b8-a563761e01ef"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fine Tuning Self Supervised Model with Supervised Learning\n",
        "in this example, fine tune the model, both with the original projection head as well as with a new projection head, and display the results of each."
      ],
      "metadata": {
        "id": "yyuPSVSCPV-V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import copy\n",
        "\n",
        "#creating duplicate models for finetuning\n",
        "model_same_head = copy.deepcopy(model)\n",
        "model_new_head = copy.deepcopy(model)\n",
        "\n",
        "#replacing the projection head with a randomly initialized head\n",
        "#for one of the models\n",
        "model_new_head.head = Head()\n",
        "\n",
        "#training models\n",
        "same_head_maxacc = supervised_train(model_same_head)\n",
        "new_head_maxacc = supervised_train(model_new_head)"
      ],
      "metadata": {
        "id": "rN8CyZRzAjWx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "aaccacb9-2f93-4fe6-8daa-b17022adcebd"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 20000/20000 [14:13<00:00, 23.44it/s]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "max accuracy: 0.5972\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 20000/20000 [14:22<00:00, 23.18it/s]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "max accuracy: 0.6363\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Discussion\n",
        "As can be seen, pure supevised learning perfomed the worst, self supervised learning with supervised learning performed second best, and self supervised learning with supervised learning on a new head performed best.\n",
        "\n",
        "These results are purely demonstrative; there was no significant hyperparameter optimization which would be necessary in production machine learning tasks. However, this notebook does proove the theoretical utility of self supervision, and the importance of careful refinement of the projection head.\n",
        "\n",
        "**Results**\n",
        "\n",
        " - Only supervised learning: 52.5% accuracy\n",
        " - SSL and supervised: 59.7% accuracy\n",
        " - SSL and supervised on a new head: 63.6%\n"
      ],
      "metadata": {
        "id": "f6MOCQyIPxnG"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "NRGE4qvlqQAw"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}